JAVA 핵심 정리
☕

JAVA 핵심 정리

Description
Springboot 개발 전 Java 공부
category
Development
Tag
Java
Date
Nov 15, 2023 11:48 AM

자료형

java의 자료형은 논리형, 문자형, 정수형, 실수형이 있다.
//논리형
boolean TF = true; 
//문자형
char ch = 'A'; 
String st = "hihi";
//정수형
byte by = 1;
short sh = 2;
int in = 3;
long lo = 4;
//실수형
float fl = 1.2f;
double dou = 1.2d;

출력

출력에는 print,printf,println이 있다.
public class Main {
    public static void main(String[] args){
        int test = 123;

        System.out.println("test : "+test); //자동 줄 바꿈
        System.out.printf("test : %d\n", test); // 변수 호출 시 지시자 사용 필수
        System.out.print("test : "+test);
    }
}

입력값

화면에서 입력받기
import java.util.*;

Scanner scanner = new Scanner(System.in);
import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        System.out.println("두자리 정수를 입력해주세요.>");
        String input = scanner.nextLine();
        int num = Integer.parseInt(input); //형변환

        System.out.println(num);
        System.out.printf("%d", num); //지시자 사용
    }
}
 

배열

“배열은 같은 타입의 여러 변수를 하나의 묶음으로 다루는 것”
public class Main {
    public static void main(String[] args){
        int[] score = new int[5]; // 배열 선언 및 생성

        int[] test = {1,2,3,4,5}; // 배열 초기화

        for (int i=0; i < score.length; i++){ // 배열 값 초기화
            score[i] = i;
        }

        for (int i=0; i < score.length; i++){ // 배열 값 하나씩 출력
            System.out.println(""+score[i]+"/"+test[i]);
        }
    }
}
 

조건문

JAVA에서의 조건문은 if 와 switch 가 있다.

if

public class Main {
    public static void main(String[] args){
        int a = 1;
        int b = 1;
        int c = 3;

        if (a==1&&b==1){
            System.out.println("a와 b는 1이다.");
            if (c>0){
                System.out.println("c는 0보다 큽니다.");
            }
        }
        else if(a==1){
            System.out.println("a만 1이다.");
        }
        else if(b==1){
            System.out.println("a만 1이다.");
        }
        else{
            System.out.println("a,b 둘다 1이 아니다.");
        }

    }
}

switch

조건문이 맞으면 이후의 문장들도 순차적으로 실행하기 때문에 break문을 사용해 주어야 한다.
public class Main {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int level = Integer.parseInt(scanner.nextLine());

        switch (level){
            case 1 :
                System.out.println("1이다.");
                break;
            case 2 :
                System.out.println("2이다.");
                break;
            case 3 :
                System.out.println("3이다.");
                break;
            case 4 :
                System.out.println("4이다.");
                break;
        }
    }
}
 

반복문

반복문은 for, while, do-while이 있다.

for문

public class Main {
    public static void main(String[] args){
        int[] stack = new int[5];

        for (int i = 0; i<stack.length; i++ ){
            stack[i] = i;
            System.out.println("stack["+i+"] : "+stack[i]);
        }
    }
}

while문

public class Main {
    public static void main(String[] args){
        int[] stack = new int[5];
        int num = 0;
        while (true){
            if (num>=stack.length){
                break;
            }
            stack[num] = num+2;
            System.out.println(stack[num]);
            num += 1;
        }
    }
}

do-while문

조건문과 실행문의 순서를 바꾸어 놓았다. do-while문은 실행문이 최소 한번은 실행된다.
public class Main {
    public static void main(String[] args){
        int[] stack = new int[5];
        int num = 0;
        do{
            stack[num] = num+2;
            System.out.println(stack[num]);
            num += 1;
        }while (num<=stack.length-1);
    }
}
 

Class

클래스는 객체를 생성하는데 사용된다.
클래스 → 인스턴스화 → 인스턴스(객체)

객체

속성은 맴버변수, 특성, 필드, 상태
기능은 매서드, 함수, 행위
public class Main {
    public static void main(String[] args){
        Tv tv = new Tv(); // 인스턴스 사용 및 생성

        tv.channel=23; //멤버변수 초기화 
        tv.channel_up(); //매서드 호출
        System.out.println(tv.channel);
        tv.channel_down(); //매서드 호출
        System.out.println(tv.channel);
    }
}
class Tv{
    String color;
    boolean power;
    int channel;

    void power(){ //매서드
        power = !power;
    }
    void channel_up(){ //매서드
        channel ++;
    }
    void channel_down(){ //매서드
        channel --;
    }
}
 

변수

변수의 종류
선언 위치
생성시기
클래스 변수
클래스 영역
클래스가 메모리에 올라갔을 때
인스턴스 변수
클래스 영역
인스턴스가 생성되었을 때
지역 변수
메서드 영역
변수 선언문이 수행 되었을때
Class Variables
{
	int iv; //인스턴스 변수
	static int cv; //클래스 변수

	void method()
	{
		int lv = 0; //지역 변수
	}
}
 

메서드

다른 언어에서는 함수라고 한다. like python def
static 메서드는 instance 메서드를 호출 할 수 없다.
public class Main {
    public static void main(String[] args){
        Math math = new Math(); //인스턴스 생성
        
        System.out.println(math.add(1,3)); //메서드 호출
        System.out.println(Math.decimal(1,3)); //메서드 호출
    }
    
}
class Math{
    int add(int x, int y){  //메서드 선언 
        return x+y;
    }
    static int decimal(int x, int y){ //static을 이용하면 인스턴스를 생성하지 않아도 된다.
        return x-y;
    }
}
 

Overloading

조건1 : 메서드 이름이 같아야한다.
조건2 : 매개변수의 개수 또는 타입이 달라야 한다.
이름이 같은 메서드이지만 주어지는 매개변수에 따라서 다른게 동작한다.
public class Main {
    public static void main(String[] args) {
        Math mm = new Math();

        mm.print(1);
        mm.print('a');
        mm.print(1.2f);
    }
}
class Math{
    void print(int a){
        System.out.printf("%d\n",a);
    }
    void print(char a){
        System.out.printf("%c\n", a);
    }
    void print(float a){
        System.out.printf("%f\n", a);
    }
}
 

상속

상속이란, 기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것이다.
public class Main {
    public static void main(String[] args) {
        Child ch = new Child();
        Parent pa = new Parent();

        ch.a = 1;
        ch.b = 1;
        ch.c = 1;
        ch.d = 1;

        pa.a = 2;
        System.out.println(pa.a);
        System.out.println(ch.a);
    }
}
class Parent{
    int a,b,c;
}
class Child extends Parent{ //상속
    int d;
}

포함 관계

public class Main {
    public static void main(String[] args) {
        Child ch = new Child();
        Parent pa = new Parent();

        //ch.a = 1;
        //ch.b = 1;
        //ch.c = 1;
        ch.d = 1;
        ch.p.a = 1;

        pa.a = 2;
        System.out.println(pa.a);
        System.out.println(ch.p.a);
    }
}
class Parent{
    int a,b,c;
}
class Child {
    Parent p = new Parent(); //포함 관계
    int d;
}
 

Overriding

조상 클래스로 부터 받은 메서드를 변경하는것을 오버라이딩이라고 한다.
public class Main {
    public static void main(String[] args) {
        Parent p = new Parent();
        Child c = new Child();

        p.hello();
        c.hello();
    }
}
class Parent{
    int x = 3;
    void hello(){
        System.out.println("Hello");
    }
}
class Child extends Parent{
    int x = 4;
     void hello(){
        System.out.println("Hi");
        System.out.println(this.x);
        System.out.println(super.x);
    }
}
 

다형성

조상클래스 타입의 참조변수로 자손클래스의 인서턴스를 참조할 수 있도록 하는것
public class Main {
    public static void main(String[] args) {
        //Child p = new Parent(); error 다운 캐스팅 안됨 자손타입 -> 조상타입 X
        Parent p = new Child();// 조상타입 -> 자손타입 O
        Parent a = null;
        p = (Parent)a;
        a = (Child)p;
        // p.meet(); error 자손의 참조변수 호출 안됨!
        a.hello();
    }
}
class Parent{
    void hello(){
        System.out.println("Hello");
    }
}
class Child extends Parent{
    void meet(){
        System.out.println("nice to meet you!");
    }
}
 

abstract class

추상 클래스라고 한다.
구현하지 않고 선언할때 이용한다.
abstract method도 존재한다.
public class Main {
    public static void main(String[] args) {
        
    }
}
abstract class player{
    abstract void play(int pos);
    abstract void stop();
}
class AudioPlayer extends player{
    @Override
    void play(int pos) {
        System.out.println("play");
    }
    @Override
    void stop() {
        System.out.println("stop");
    }
}
 

인터페이스

인터페이스는 일종의 추상 클래스이다.
인터페이스는 추상클래스와 달리 매개변수를 가질 수 없다.
오직 추상 메서드와 상수만 가질 수 있다.
public class Main {
    public static void main(String[] args) {
        System.out.println();
    }
}
interface HI1{
    void hi();
}
interface HI2{
    void hi2();
}
interface Test extends HI1,HI2{ //다중 인터페이스 상속이 가능하다.
    final int a = 1;
    public abstract void test();
}
class Test2 implements Test{ //인터페이스를 상속할땐 implements를 이욯한다.
    public void test(){
        System.out.println(a);
    }
    @Override
    public void hi() {
        System.out.println(a);
    }
    @Override
    public void hi2() {
        System.out.println(a);
    }
}